Systems and/or methods for type inference from machine code

ABSTRACT

Systems, methods and computer readable medium described herein relate to techniques for automatic type inference from machine code. An example technique includes receiving a machine code of a program, generating an intermediate representation of the machine code, generating a plurality of type constraints from the intermediate representation, generating one or more inferred types based at least upon the plurality of type constraints, converting the generated inferred types to C types, updating the intermediate representation by applying the inferred types to the intermediate representation, and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation.

TECHNICAL FIELD

Certain example embodiments described herein relate to techniques for computer software processing. More particularly, certain example embodiments relate to techniques for reconstructing type information from machine code.

BACKGROUND AND SUMMARY OF EXAMPLE EMBODIMENTS OF THE INVENTION

For many compiled languages, source-level types are erased very early in the compilation process. As a result, further compiler passes may convert type-safe source code into type-unsafe machine code. Type-unsafe idioms in the original source and type-unsafe optimizations cause type information to be essentially non-existent in a stripped binary. The problem of recovering high-level types by performing type inference over stripped machine code is referred to as type reconstruction, and offers a useful capability in support of reverse engineering and decompilation.

Although some conventional techniques are available for determining type information from machine code, improved techniques are desired. Embodiments of the present invention provide an improved, robust and efficient technique for reconstructing type information from machine code.

According to an example embodiment, a computing system comprising at least one memory, a display and at least one processor is provided. The at least one processor is configured to execute functionality including receiving a machine code of a program, generating an intermediate representation of the machine code, generating a plurality of type constraints from the intermediate representation, generating one or more inferred types based at least upon the plurality of type constraints, converting the generated inferred types to C types, updating the intermediate representation by applying the inferred types to the intermediate representation, and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation.

The converting of the generated inferred types to C types may be performed after the inferred types are generated from the intermediate representation.

The generating of one or more inferred types may include assigning a sketch to each of the inferred types. The converting to C types may include converting the sketch to one or more of said C types, where the sketch includes a record of capabilities of the inferred type to which it is assigned.

The sketch may be represented by a tree data structure, where edges of the tree represent labels corresponding to said capabilities and nodes of the tree represent type variables or type constants.

Assigned sketches may be arranged in a lattice formed by markings relating respective sketches to one or more other sketches. Type constraint may be represented in the lattice by a path from the root with a label sequence. The markings may be configured to encode higher level information including typedef name information.

The generating a plurality of type constraints from the intermediate representation includes at least one of (A) determining inputs/outputs of each procedure, (B) determining a program call graph, and (C) determining per-procedure control flow.

The computing system may further be configured to execute functionality comprising using an abstract interpreter, generating sets of type constraints from concrete TSL semantics, inserting type schemes for externally linked functions, and simplifying each constraint set.

The computing system may further be configured to execute functionality comprising assigning sketches to type variables, and specializing type schemes based on calling contexts. Further configuration may include executing functionality comprising converting inferred sketches to C types applying heuristic conversion policies.

The generating of the inferred types may be based upon subtyping. The subtyping may be implemented using type scheme specialization of subtype based constraint sets. The generating the inferred types may include interpreting recursive data structures.

The computing system may further be configured to provide for an end user to define or adjust an initial type hierarchy at run time.

The generating of a plurality of type constraints may include splitting out read and write capabilities of a pointer to have separate constraints in the plurality of type constraints. The plurality of type constraints may be generated in a bottom-up fashion over the strongly-connected components of the call graph, and where sketches are assigned to type variables while the call graph is being traversed bottom-up.

The generating of the plurality of type constraints may include creating a simplified plurality of type constraints by operations including lazily evaluates pointer derived constraints, while non-lazily evaluating other constraints.

According to another example embodiment, a method performed by at least one processor to infer types from a program is provided. The method includes receiving a machine code of the program, generating an intermediate representation of the machine code, generating a plurality of type constraints from the intermediate representation, generating one or more inferred types based at least upon the plurality of type constraints, converting the generated inferred types to C types, updating the intermediate representation by applying the inferred types to the intermediate representation, and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation.

According to another example embodiment, a non-transitory computer-readable storage medium is provided. Instructions stored on the storage medium, when executed by a computer, may cause the computer to perform operations including receiving a machine code of a program, generating an intermediate representation of the machine code, generating a plurality of type constraints from the intermediate representation, generating one or more inferred types based at least upon the plurality of type constraints, converting the generated inferred types to C types, updating the intermediate representation by applying the inferred types to the intermediate representation, and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation.

These aspects, features, and example embodiments may be used separately and/or applied in various combinations to achieve yet further embodiments of this invention.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features and advantages may be better and more completely understood by reference to the following detailed description of exemplary illustrative embodiments in conjunction with the drawings, of which:

FIG. 1 is a flow chart illustrating the overall process for type inference according to one or more embodiments;

FIG. 2 illustrates further details of type constraint generation for type inference, according to some embodiments;

FIG. 3 illustrates a block diagram of instruction logic for the system of FIG. 1, according to some embodiments;

FIG. 4 illustrates example labels (i.e. field labels) according to some embodiments;

FIG. 5 illustrates deduction rules, type variables and labels according to some embodiments;

FIG. 6 illustrates example C code, disassembled version of the example C code, inferred type scheme and a reconstructed C type, according to some embodiments;

FIG. 7 illustrates example generated constraints based on the code of FIG. 6, in accordance with some embodiments;

FIG. 8 illustrates an example lattice according to some embodiments;

FIG. 9 illustrates example code snippets;

FIG. 10 illustrates pseudocode for constraint generation, according to some embodiments;

FIGS. 11A-G illustrate interpretations by an abstract interpreter, according to some embodiments.

FIG. 12 illustrates pseudocode for a saturation technique, according to some embodiments;

FIG. 13 illustrates pseudocode for inferring types according to some embodiments;

FIG. 14 illustrates pseudocode for converting a transducer from a set of pushdown system rules, according to some embodiments;

FIG. 15 illustrates pseudocode for converting a transducer to a pushdown system, according to some embodiments;

FIG. 16 illustrates pseudocode for procedure specialization, according to some embodiments;

FIG. 17 illustrates pseudocode for computing sketches from constraint sets, according to some embodiments;

FIGS. 18A and 18B illustrate example sketches according to some embodiments;

FIG. 19 illustrates a sketch instantiating a type scheme in FIG. 6, according to some embodiments; and

FIG. 20 illustrates example machine code for void ƒ(int x, char* y) invoked as ƒ(0, NULL).

DETAILED DESCRIPTION OF EXAMPLE EMBODIMENTS OF THE INVENTION

As noted above, machine code, especially stripped binaries of programs, may have all or almost all the type information of variables, constants and other idioms (i.e., phrases used in source code) removed. Such removal is often done for reasons such as optimizing the code size, reducing memory footprint, etc.

However, many applications may require the reconstruction of type information for such stripped binaries. For example, reverse engineering the source code from a binary would in many cases require such type reconstruction. The reverse engineering may be for reasons such as, bug-fixing a program for which the original source code is no longer available, for determining the operation and source of a malware, examining the security of a binary, and the like.

Some example embodiments provide a novel static type inference algorithm for machine code that supports recursive types, polymorphism, and subtyping. The example embodiments have yielded more accurate inferred types than existing conventional type reconstruction techniques, while also enabling new capabilities such as, but not limited to, reconstruction of pointer const annotations with very high (e.g., 98%) recall. Some example embodiments can operate on weaker program representations than the current state of the art conventional techniques, thereby removing the need for high-quality points-to information that may be impractical to obtain from a stripped binary, or too costly in terms of the required processing, to compute.

Some example embodiments provide a machine-code type inference tool that can find regular types using pushdown systems. The tool includes several features targeted at improved types for reverse engineering, decompilation, and high-level program analyses. These features include: inference of most-general type schemes; inference of recursive structure types; sound analysis of pointer subtyping; tracking of customizable, high-level information such as purposes (e.g., see tags #FileHandle and #SuccessZ in FIG. 6) and typedeƒ names; inference of type qualifiers such as const; ability to operate without high-quality points-to data; and, more accurate recovery of source-level types.

Like some conventional techniques, certain example embodiments provide a principled static type inference algorithm that can be applied to stripped binaries. However, unlike conventional techniques, certain example embodiments follow the principled type inference phase by a second phase that uses heuristics to adapt the inferred types to human-readable C types before output or display. By factoring the type inference process into two phases, the example embodiments sequester potentially unsound heuristics and quirks of the C type systems from the sound core of the type inference engine. This capability for sequestering adds a degree of freedom to the design space so that a relatively complex type system can be leveraged during type analysis, while still emitting familiar C types for the benefit of a process such as, for example, a more user-friendly reverse engineering process. In some embodiments no converting of inferred types to C types occur, until the inferring of all type information for an intermediate representation has completed.

There are many challenges to performing type inference on binaries of programs and on many common machine code idioms that lead to sophisticated demands on the feature set of a type system. These challenges include, many optimizations being performed on the code after type erasure; polymorphic functions; recursive types; offset and reinterpreted pointers; disassembly failures; cross-casting and bit twiddling, incomplete points-to information, and adhoc subtyping. The type system of certain example embodiments is designed to correctly type machine code idioms in the presence of one or more of these challenges. This design has resulted in certain example embodiments having a rich type system including features such as recursively constrained type schemes that have not previously been applied to machine code type inference.

When optimizations have been performed on the code after type erasure, since type erasure typically occurs early in the compilation process, many compiler optimizations may take well-typed machine code and produce functionally equivalent but ill-typed results. Three common optimization techniques require particular care: the re-use of stack slots, the use of a variable as a syntactic constant, and early returns along error paths.

The optimizations concerning the re-use of stack slots takes advantage of the aspect that, if a function uses two variables of the same size in disjoint scopes, there is no need to allocate two separate stack slots for those variables. Instead, the optimizer may reuse a stack slot from a variable that has dropped out of scope. This optimization can be performed even if the new variable has a different type, and may even apply to the stack slots used to store formal-in parameters. For example, when a function's argument is no longer needed, the optimizer can overwrite the argument with a local variable of an incompatible type. More generally, in order to correctly address binaries in which re-use of stack variables has been performed, the type reconstruction in certain example embodiments does not assume that the map from program variables to physical locations is one-to-one. Even the weaker assumption that the program variables inhabiting a single physical location at different times will all belong to a single type may not be correct when used in relation to some binaries, and is not an assumption made in certain example embodiments.

As noted above, another optimization that may have been performed after type erasure occurs with respect to semi-syntactic constants. Consider a function with signature void ƒ(int x, char* y) which is invoked as ƒ(0, NULL). This may be compiled to x86 machine code similar to FIG. 20. This represents a code-size optimization, because push eax (“eax” represents the accumulator in the example x86 machine code) can be encoded in one byte instead of the five bytes needed to push an immediate value (e.g., 0). In situations such as this, the example embodiments operate without unifying the type variables for x and y; here, eax is being used more like a syntactic constant than a dynamic value that should be typed.

Another optimization concerns the fortuitous reuse of values. A related situation is illustrated in the common control flow pattern represented by the snippet of C and the corresponding machine code in FIG. 6. Note that on procedure exit, the return value in eax may have come from either the return value of S2T or from the return value of get_S (if NULL). Certain example embodiments detect this situation so that a false relationship is not caused between the incompatible return types of get_T and get_S.

In certain example embodiments, the above described challenges posed by optimizations performed after type erasure are addressed through a combination of type system features (e.g., subtyping instead of unification) and program analyses (e.g., reaching definitions for stack variables and trace partitioning). Whereas, in unification a substitution is found that makes two given terms equal, in subtyping substitutions involve supertype-subtype relationship between the terms. A reaching definition for an instruction is an earlier instruction whose target variable can reach (be assigned to) the given one without an intervening assignment. An example trace partitioning scheme that may be adapted for one or more example embodiments is described for example in L. Mauborgne and X. Rival. “Trace partitioning in abstract interpretation based static analyzers”, in Programming Languages and Systems, pages 5-20, Springer, 2005.

With respect to the challenge to type reconstruction posed by polymorphic functions, the inventors were surprised to discover that, although not directly supported by the C type system, most programs define or make use of functions that are effectively polymorphic. A well known example among these may be malloc for which the return value is expected to be immediately cast to some other type T*. Thus, each call to malloc may be thought of as returning some pointer of a different type. The type of malloc is effectively not size_t→void*, but rather ∀τ.size_t→τ*.

The problem of a polymorphic malloc can be mitigated by treating each call-site p as a call to a distinct function malloc_(p), each of which may have a distinct return type T_(p)*. Unfortunately it may not be sufficient to treat a handful of special functions like malloc this way: binaries that utilize user-defined allocators and wrappers to malloc are commonly in use. Type reconstruction tools according to certain example embodiments are capable of accurately identifying and duplicating all of these functions for each call-site.

A similar problem like in malloc exists for functions such as free, which is polymorphic in its lone parameter. Even more complex are functions like memcpy, which is polymorphic in its first two parameters and its return type, though the three types are not independent of each other. Furthermore, the polymorphic type signatures “malloc: ∀τ.size_t→τ*”, “ƒree: ∀τ.τ*→void”, and “memcpy: ∀α, β.(β⊂α)⇒(α*×β*×size_t)→α*”, used in some embodiments, are all more informative to the reverse engineer than the standard C signatures. For example, without such informative signatures, the reverse engineering technician may not know that the void* returned by malloc is not meant to be an opaque handle, but rather should be cast to some other pointer type.

In compiled C++ binaries, polymorphic functions are even more common. For example, a class member function must potentially accept both base_t* and derived_t* as types for this.

Example embodiments provide for polymorphic functions as a common feature of machine code, and include the capability to infer polymorphic types of nontrivial complexity. Foster, Johnson, Kodumal, and Aiken, “Flow insensitive type qualifiers”, ACM Transactions on Programming Languages and Systems (TOPLAS), 28(6):1035-1087, 2006, describes polymorphic types and notes that using bounded polymorphic type schemes for libc functions increased the precision of type-qualifier inference, at the level of source code.

Another challenge for type reconstruction concerns recursive types. The relevance of recursive types for decompilation was recently discussed by Schwartz et al. E. J. Schwartz, J. Lee, M. Woo, and D. Brumley, “Native x86 decompilation using semantics—preserving structural analysis and iterative control-flow structuring”, in Proceedings of the USENIX Security Symposium, page 16, 2013, where lack of a recursive type system for machine code was cited as an important source of imprecision. Since recursive data structures are relatively common, it is desirable, as in certain example embodiments, that a type inference scheme for machine code be able to represent and infer recursive types natively.

Offset and reinterpreted pointers pose another challenge to type reconstruction. Unlike in source code, there is no syntactic distinction in machine code between a pointer-to-struct and a pointer-to-first-member-of-struct. For example, if X has type struct {char*, FILE*, size_t}* on a 32-bit platform, then it should be possible to infer that X+4 can be safely passed to ƒclose; conversely, if X+4 is passed to ƒclose the system may need to infer that X points to a structure that, at offset 4, contains a FILE*. This affects the typing of local structures, as well: a structure on the stack may be manipulated using a pointer to its starting address or by manipulating the members directly, e.g., through the frame pointer.

These idioms, along with casts from derived* to base*, fall under the general class of physical or non-structural subtyping. Physical subtyping is described in A. Slowinska, T. Stancescu, and H. Bos. Howard, “A dynamic excavator for reverse engineering data structures”, in Proceedings of the 18th Annual Network and Distributed System Security Symposium (NDSS '11), 2011. Non-structural subtyping is described in J. Palsberg, M. Wand, and P. O'Keefe, “Type inference with non-structural subtyping”, Formal Aspects of Computing, 9(1): 49-67, 1997.

In certain example embodiments, these forms of sub-typing are implemented using type scheme specialization. Some embodiments use parameter-offset analysis to obtain additional hints about the extent of local variables. Type scheme specialization in embodiments is discussed below. An example parameter-offset analysis that can be implemented in embodiments is described in D. Gopan, E. Driscoll, D. Nguyen, D. Naydich, A. Loginov, and D. Melski, “Data-delineation in software binaries and its application to buffer-overrun discovery”, in Proceedings of the 37th International Conference on Software Engineering, Volume 1, ICSE '15, pages 145-155, Piscataway, N.J., USA, 2015. IEEE Press. ISBN 978-1-4799-1934-5.

Yet another challenge for type reconstruction are disassembly failures. The problem of producing correct disassembly for stripped binaries is considered to be equivalent to the Halting Problem. As a result, example embodiments do not operate under the assumption that the reconstructed program representation is completely correct. Example embodiments safeguard against incorrect disassembly or analysis results from one part of the binary influencing the correct type results gathered for the rest of the binary.

Type systems that model value assignments as type unifications are vulnerable to over-unification issues caused by faulty intermediate representations (IR). Since unification is non-local, bad constraints in one part of the binary can degrade all type results. Another instance of this problem arises from the use of register parameters. Although the x86 cdecl calling convention uses the stack for parameter passing, most optimized binaries include many functions that pass parameters in registers for speed. Often, these functions do not conform to any standard calling convention. Although generally only true register parameters are reported, the occasional false positive may occur.

Type reconstruction methods that are based on unification are generally sensitive to precision loss due to false positive register parameters. A common case is the “push ecx” idiom that reserves space for a single local variable in the stack frame of a function ƒ. If ecx is incorrectly viewed as a register parameter of ƒ in a unification-based scheme, whatever type variables are bound to ecx at each call-site to ƒ will be falsely unified. These over-unifications may be a persistent and hard-to-diagnose source of imprecision. Example embodiments' subtype-based constraint sets avoid the need for adhoc prophylactics against over-unification, thus eliminating a disproportionately large and unprincipled component of type analysis caused by conventional techniques when addressing over-unification.

Cross-casting and bit-twiddling is yet another challenge for type reconstruction. Many type-unsafe idioms are in common use even at the level of source code. Many of these idioms operate by directly manipulating the bit representation of a value, either to encode additional information or to perform computations that are not possible using the type's usual interface. Some common examples include: hashing values by treating them as untyped bit blocks; stealing unused bits of a pointer for tag information, such as whether a thunk has been evaluated; reducing the storage requirements of a doubly-linked list by XOR-combining the next and prev pointers; and directly manipulating the bit representation of another type.

Because of these type-unsafe idioms, it is important that a type inference scheme continues to produce useful results even in the presence of apparently contradictory constraints. This situation is handled in example embodiments in any of three ways: separating the phases of constraint entailment, solving, and consistency checking; modeling types with sketches, which carry more information than C types; and using unions to combine types with otherwise incompatible capabilities (e.g., τ is both int-like and pointer-like).

Incomplete points-to information also poses a challenge to type reconstruction. Degradation of points-to accuracy on large programs has been identified as a frequent source of type-precision loss in many other systems. Example embodiments provide high-quality types even in the presence of relatively weak points-to information. Precision can be further improved by increasing points-to knowledge via machine-code analyses such as value-set analysis (VSA) in some example embodiments, but good results are already attained with no points-to analysis beyond the simpler problem of tracking the stack pointer in other example embodiments.

Another challenge to type reconstruction is presented in adhoc subtyping. Programs may define an adhoc type hierarchy via typedefs. This idiom appears in the Windows™ API, where a variety of handle types are all defined as typedefs of void*. Some of the handle types are to be used as subtypes of other handles; for example, a GDI handle (e.g., HGDI) is a generic handle used to represent any one of the more specific HBRUSH, HPEN, etc. In other cases, a typedef may indicate a supertype, as in LPARAM or DWORD; although these are typedefs of int, they have the intended semantics of a generic 32-bit type, which in different contexts may be used as a pointer, an integer, a flag set, and so on.

To accurately track adhoc type hierarchies requires a type system based upon subtyping rather than on unification. The ability for the end user to define or adjust the initial type hierarchy at run time is useful. Example embodiments provide this feature by parameterizing the main type representation by an uninterpreted lattice Λ. FIG. 1 is a flowchart of the overall process of type inferring according to one or more example embodiments, and FIG. 2 is a flowchart for process for determining the inferred types. FIG. 3 illustrates a blockdiagram showing the instruction logic components. FIGS. 1-3 are described later in this document, after certain aspects of the technique of type inference is described.

The type system of certain example embodiments is based upon the inference of recursively constrained type schemes. The recursively constrained type schemes abstract over a set of types subject to a type constraint set C. The solutions to type constraint sets are modeled by sketches. A sketch is associated to a value and consists of a record of capabilities which that value holds, such as whether it can be stored to, called, or accessed at a certain offset. Sketches also include markings drawn from a customizable lattice (Λ, ∨, ∧, <), used to propagate high-level information such as typedef names and domain-specific purposes during type inference.

The language of type constraints used by example embodiments may be weak enough that, for any type constraint set C, satisfiability of C can be reduced (e.g., in cubic time) to checking a set of scalar constraints κ₁<: κ₂, where κ_(i) are constants belonging to the lattice Λ. Due to the reduction of constraint satisfiability to scalar constraint checking, expensive satisfiability checks during type inference can be omitted or reduced in example embodiments. Instead, such checks may be delayed until the final stage of the type inference process when determined types are converted to C types for display to the user, providing an efficient place to instantiate union types that resolve any remaining inconsistencies. Since compiler optimizations and type-unsafe idioms in the original source frequently lead to program fragments with unsatisfiable type constraints (e.g., due to disassembly failures, cross-casting and bit twiddling), this capability is particularly desirable because of its capability of increasing the overall efficiency and speed of operation in example embodiments.

Description of the syntax of the constraint type system used in certain example embodiments may be assisted by defining some terminology. Throughout this description, a set V of type variables, an alphabet Σ of labels (e.g., also referred to as field labels), and a function (⋅): Σ→{⊕, θ}) denoting the variance of each label is considered. V may optionally also include any type constants, such as, for example, named types (e.g., size_t, FILE, HANDLE) or semantics tags (e.g., “error code”, “thread id”, “username”, “filename”, “file mode” etc.). The set Σ of labels is not required to be finite, and some embodiments may accommodate an infinite number of labels and other embodiments may handle only a finite number of labels. For simplicity, and without limitation, the description on this document is focused primarily on those labels shown in FIG. 4.

Within V, as noted above, there may be a distinguished set of type constants. These type constants are symbolic representations κ of elements κ belonging to some lattice, but may otherwise be unintepreted. In certain example embodiments, the type constants may be type names or semantic tags.

A derived type variable is an expression of the form αw with α∈V and w∈Σ*. The variance of a label R encodes the subtype relationship between α.l and β.l when α is a subtype of β, formalized in rules S-FIELD_(⊕) and S-FIELD_(θ) shown in FIG. 5. A type constraint is an expression of the form VAR X (“existence of the derived type variable X”) or X⊂Y (“X is a subtype of Y”), where X and Y are derived type variables. A type constraint set over V is a finite collection C of type constraints, where the type variables in each type constraint are either type constants or members of V. The labels used to form derived type variables in example embodiments represent capabilities of that type. For example, the constraint VAR α.load means α is a readable pointer, and the derived type variable α.load represents the type of the memory region obtained by loading from α. The constraint generation may generate a constraint set per procedure. C entails c, denoted C├c, if c can be derived from the constraints in C using the deduction rules shown, for example, in FIG. 5. Projections may be allowed: given a constraint set C with free variable τ, the projection ∃ τ.C binds τ as an “internal” variable in the constraint set. See τ in FIG. 6 for an example. A description of constraint projection is provided in Z. Su, A. Aiken, J. Niehren, T. Priesnitz, and R. Treinen, “The first-order theory of subtyping constraints”, in Proceedings of the 29th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '02, pages 203-216. ACM, 2002.

The translation of operations in a program binary, in certain example embodiments, to type constraints and thereafter to inferred types is described in the following paragraphs using C syntax for clarity. Clearly embodiments are not limited to presenting type information in C syntax. The full conversion from disassembly to type constraints is described in the reference Noonan, Loginov and Cok, “Polymorphic type inference for machine code” ACM SIGPLAN Notices—PLDI '16, Volume 51 Issue 6, June 2016, pages 27-41, ACM New York, N.Y., USA (herein referred to as “Noonan”) in Appendix A. Noonan is hereby incorporated by reference in its entirety.

Example constraint generation for value copy operations, load and store operations, and function calls are described below. For a value copy operation, when a value is moved between program variables in an assignment like x:=y, example embodiments may make the conservative assumption that the type of x may be upcast to a supertype of y. A type constraint of the form Y⊂X may be generated.

For loads and store operations, if p is a pointer to a 32-bit type, and a value is loaded into x by the assignment x:=*p, then an example embodiment may generate a constraint of the form P.load.σ32@0⊂X. Similarly, a store *q:=y results in the type constraint Y⊂Q.store.σ32@0. In some of the described pointer-based examples in this description the final “.σN@k” access after a .load or .store to is omitted simplify the presentation.

For function calls, if the function ƒ is invoked by y:=ƒ(x), example embodiments generate the type constraints X⊂F.in and F.out⊂Y, reflecting the flow of actuals to and from formals. Note that if A.in =X and A.out=Y are defined, then the two constraints are equivalent to F⊂A by the rules of FIG. 5. This encodes that the called function's type must be at least as specific as the type used at the call-site.

One of the primary goals of the type inference engine in example embodiments is to associate to each procedure a type scheme. A type scheme can be represented by an expression of the form ∀α.C⇒α₁ where ∀Vα=∀α₁ . . . ∀α_(n) is quantification over a set of type variables, and C is a constraint set over {α_(i)}i=_(1 . . . n). Type schemes provide a way of encoding the pre- and post-conditions that a function places on the types in its calling context. Without the constraint sets, the system would only be able to represent conditions of the form “the input must be a subtype of X” and “the output must be a supertype of Y”. The type constraint set C can be used to encode more interesting type relations between inputs and outputs, as in the case of memcpy discussed above in relation to challenges posed for type reconstructions by polymorphic functions. For example, a function that returns the second 4-byte element from a struct* may have the type scheme ∀τ. (τ.in.load.σ32@4⊂τ.out)⇒τ.

Deduction rules for one or more example embodiments are shown in FIG. 5. Most of the rules are self-evident under the interpretation above regarding constraints, but it may be helpful to provide some additional motivation regarding some others. In FIG. 5, α, β, γ represent derived type variables, and l represents a label in Σ.

S-FIELD_(⊕) and S-FIELD_(θ) are rules to ensure that labels act as co- or contravariant type operators, generating subtype relations between derived type variables from subtype relations between the original variables. T-INHERITL specifies that a subtype should have all capabilities of its supertype, and T-INHERITR moves capabilities in the other direction. Taken together, T-INHERITL and T-INHERITR require that two types in a subtype relation must have exactly the same set of capabilities. This is a form of structural typing, ensuring that comparable types have the same shape.

Structural typing appears to be at odds with the need to cast more capable objects to less capable ones, as described above in relation to the offset and reinterpreted points. Indeed, T-INHERITR eliminates the possibility of forgetting capabilities during value assignments. But the systems according the embodiments maintain this capability at procedure invocations by the use of polymorphic type schemes. An explanation of how type-scheme instantiation enables forgetting fields of an object appears below in relation to non-structural subtyping and T-INHERITR, with more details in Noonan which is incorporated by reference.

These rules ensure that example embodiments can be used to perform “iterative variable recovery”. The lack of iterative variable recovery has been cited as a common cause of incorrect decompilation in conventional type inference systems.

The S-POINTER rule is a consistency condition ensuring that the type that can be loaded from a pointer is a supertype of the type that can be stored to a pointer. Without this rule, pointers would provide a channel for subverting the type system.

The deduction rules such as that in FIG. 5 can each be reduced mathematically to a normal form. An encoding of the normal forms as transition sequences in a modified pushdown system may be used in example embodiments to provide a compact representation of the entailment closure C={c|C├c}. The pushdown system (described below) modeling C is queried and manipulated in example embodiments to provide most of the interesting type inference functionality.

With respect to modeling parameters soundly in the presence of subtyping, with respect to the example code shown in FIG. 9, since the type variables P and Q associated to p, q can be seen to be pointers, one can begin by setting P=Ptr(α), Q=Ptr(β), The first program on the left side of FIG. 9 may generate the constraint set C₁={Ptr(β)⊂Ptr(α), X⊂α, β⊂Y}, while the second (program on the right side of FIG. 9) generates C₂={Ptr(β)⊂Ptr(α), X⊂β, α⊂Y}. Since each program has the effect of copying the value in x toy, both constraint sets should satisfy C_(i)├X⊂Y. To do this, the pointer subtype constraint must entail some constraint on α and β.

The root cause of the difficulty in selecting a constraint on α and β is due to conflating two capabilities that (most) pointers have: the ability to be written through, and the ability to be read through. In certain example embodiments, these two capabilities are modeled using different field labels .store and .load. The .store label is contravariant, while the .load label is covariant. By splitting out the read- and write-capabilities of a pointer, the example embodiments achieve a sound account of pointer sub-typing that does not degenerate to type equality. Note the importance of the consistency condition S-POINTER: this rule ensures that writing to a pointer and reading a result out cannot subvert the type system.

It was noted in relation to deduction rules above that the rule T-INHERITR leads to a system with a form of structural typing: any two types in a subtype relation must have the same capabilities. Superficially, this seems problematic for modeling typecasts that forget about fields, such as a cast from derived* to base* when derived* has additional fields. The missing piece that allows example embodiments to effectively “forget” capabilities is instantiation of callee type schemes at a call-site. To demonstrate how polymorphism enables “forgetfulness”, consider the example type scheme ∀F. (∃τ.C)⇒F from FIG. 6. The function close_last can be invoked by providing any actual-in type α such that α⊂F.in_(stack0); in particular, α can have more fields than those required by C. Select a more capable type for τ in C. In effect, the example embodiments use specialization of polymorphic types to model non-structural subtyping idioms, while subtyping is used only to model structural subtyping idioms. This restricts the example embodiments' introduction of non-structural subtypes to points where a type scheme is instantiated, such as at a call-site.

The simple type system defined by the deduction rules of FIG. 5 defines the syntax of valid derivations in the type system of certain example embodiments. The constraint solver of example embodiments is designed to find a simple representation for all conclusions that can be derived from a set of type constraints. Yet, in example embodiments, there is no notion of what a type is inherent to the deduction rules of FIG. 5.

The inventors found that introducing C-like types at the level of constraints or types resulted in too much loss of precision when working with the challenging examples described in relation to the challenges faced when performing type reconstruction. Consequently the inventors developed the notion of a sketch, a certain kind of regular tree labeled with elements of an auxiliary lattice Λ. Sketches are related to the recursive types studied in R. M. Amadio and L. Cardelli, “Subtyping recursive types”. ACM Transactions on Programming Languages and Systems (TOPLAS)”, 15(4):575-631, 1993, and D. Kozen, J. Palsberg, and M. I. Schwartzbach, “Efficient recursive subtyping”, Mathematical Structures in Computer Science, 5(01):113-125, 1995, but do not depend on a priori knowledge of the ranked alphabet of type constructors.

A sketch is a (possibly infinite) tree T with edges labeled by elements of Σ and nodes marked with elements of a lattice Λ, such that T only has finitely many subtrees up to labeled isomorphism. By collapsing isomorphic subtrees, sketches can be represented as deterministic finite state automata with each state labeled by an element of Λ. The set of sketches admits a lattice structure, with operations described in already incorporated Noonan at Appendix E.

The lattice of sketches serve as the model in which type constraints are interpreted in example embodiments. The interpretation of the constraint VAR α.u is “the sketch S_(α) admits a path from the root with label sequence u”, and α.u⊂β.v is interpreted as “the sketch obtained from S_(α) by traversing the label sequence u is a subsketch (in the lattice order) of the sketch obtained from S_(β) by traversing the sequence v.”

The main utility of sketches is that they are nearly a free tree model (see e.g., F. Pottier and D. Re'my, “The essence of ML type inference”, in B. C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 10, MIT Press, 2005) of the constraint language. Any constraint set C is satisfiable over the lattice of sketches, as long as C cannot prove an impossible subtype relation in the auxiliary lattice Λ. In particular, the fragment of C that does not reference constants in Λ can always be solved. Stated operationally, the tree structure of sketches that potentially solve C can always be recovered. In this context “solved” means that sketches can always be directly constructed that conform to any given constraints, if the labels on the nodes of the sketches are disregarded. This observation is formalized in Noonan.

In example embodiments, a large auxiliary lattice Λ containing hundreds of elements that includes a collection of standard C type names, common typedefs for popular APIs, and user-specified semantic classes such as #FileHandle in FIG. 6 may be used. This lattice helps model adhoc subtyping and preserve high-level semantic type names, as discussed above in relation to challenges posed by adhoc subtyping. An example lattice is shown in FIG. 8 —although only a lattice of some sematic classes.

Certain example embodiments are built on GrammaTech's machine-code analysis tool CodeSurfer® for Binaries. CodeSurfer® performs common program analyses on binaries for multiple CPU architectures, including x86, x86-64, and ARM. CodeSurfer® is used to recover a high-level IR from the raw machine code; type constraints are generated directly from this IR, and resolved types are applied back to the IR and become visible to the GUI and later analysis phases.

CodeSurfer® achieves platform independence through TSL (see J. Lim and T. Reps, “TSL: A system for generating abstract interpreters and its application to machine—code analysis”, ACM Transactions on Programming Languages and Systems (TOPLAS), 35(1):4, 2013), a language for defining a processor's concrete semantics in terms of concrete numeric types and mapping types that model register and memory banks. Interpreters for a given abstract domain are automatically created from the concrete semantics simply by specifying the abstract domain A and an interpretation of the concrete numeric and mapping types. Certain example embodiments uses CodeSurfer's® recovered IR to determine the number and location of inputs and outputs to each procedure, as well as the program's call graph and per-procedure control-flow graphs. An abstract interpreter then generates sets of type constraints from the concrete TSL instruction semantics. A detailed account of the abstract semantics for constraint generation appears in Appendix A of Noonan which is incorporated by reference.

After the initial IR is recovered, type inference proceeds in two stages: first, type constraint sets are generated in a bottom-up fashion over the strongly-connected components of the call graph. Once type schemes are available, the call graph is traversed bottom-up, assigning sketches to type variables. During this stage, type schemes are specialized based on the calling contexts of each function. The final phase of type resolution converts the inferred sketches to C types for presentation to the user. Since C types and sketches are not directly comparable, this resolution phase necessarily involves the application of heuristic conversion policies.

Heuristic rules may be used in determining the displayable types corresponding to each internal type. Restricting the heuristic policies to a single post-inference phase, as enabled the use of sketches by example embodiments, provides the example embodiments with substantial flexibility to generate high-quality, human-readable C types (e.g., C types) while maintaining soundness and generality during type reconstruction.

A simplification algorithm is at the core of the constraint solver in example embodiments. The complete algorithm can be found in Noonan at Appendix D. A type scheme is inferred using the simplification algorithm. The goal of the simplification algorithm is to take an inferred type scheme ∀V α. C⇒τ for a procedure and create a smaller constraint set C′ such that any constraint on τ implied by C is also implied by C′. Let C denote the constraint set generated by abstract interpretation of the procedure being analyzed, and let α be the set of free type variables in C. ∀α. C⇒τ can be used as the constraint set in the procedure's type scheme, since the input and output types used in a valid invocation of ƒ are tautologically those that satisfy C. Yet as a practical matter the constraint set may not be used directly, since this would result in constraint sets with many useless free variables and a high growth rate over nested procedures.

Instead, example embodiments seek to generate a simplified constraint set C′ such that if c is an “interesting” constraint and C├c then C′├c as well. For a type variable τ, a constraint is called interesting if it has one of the following forms: a capability constraint of the form VAR τ.u; a recursive subtype constraint of the form τ.u⊂τ.v; and a subtype constraint of the form τ.u⊂κ or κ⊂τ.u, where κ is a type constant. A constraint set C′ may be called a simplification of C if C′├c for every interesting constraint c such that C├c. Since both C and C′ entail the same set of constraints on τ, it is valid to replace C with C′ in any valid type scheme for τ. Example embodiments may use one or more the heuristics proposed in Fhndrich and Aiken, “Making set-constraint program analyses scale”, in Workshop on Set Constraints, 1996, during constraint solving. Two example heuristics are elimination of intermediate variables (X<Y<Z becoming X<Z, with Y eliminated) and collapsing of cycles (replacing X<Y, Y<Z, Z<X with just X, eliminating Y and Z).

The constraint-simplification algorithm works on a constraint set C by building a pushdown system P_(C) whose transition sequences represent valid derivations of subtyping judgments. An unconstrained pushdown system is a triple P=(V, Σ, Δ) where V is the set of control locations, Σ is the set of stack symbols, and Δ⊂(V×Σ*)² is a (possibly infinite) set of rewrite rules. A rewrite rule can be denoted by (X; u)c→(Y; v) where X, Y ∈V and u, v∈E*. The set of configurations may be defined to be V×Σ*. In a configuration (p, w), p is called the control state and w the stack state. Using a pushdown system provides a finite and efficient model for working with the infinite set of constraints entailed by (or implied by) C. Efficient algorithms exist for working with pushdown systems, which (with modifications as described) allow efficient manipulation of these infinite constraint sets.

Example embodiments require neither the set of stack symbols nor the set of rewrite rules to be finite. This freedom is needed to model the derivation S-POINTER of FIG. 5, which corresponds to an infinite set of rewrite rules.

An unconstrained pushdown system P determines a rewrite relation → on the set of configurations: (X, w)→(Y, w^(t)) if there is a suffix s and a rule (X; u)c→(Y; v) such that w=us and wt=vs. The transitive closure of → is denoted *. With this definition, a key theorem behind the simplification algorithm of certain example embodiments can be stated as follows. Let C be a constraint set and V a set of base type variables, and define a subset SC of (V∪Σ)*×(V∪Σ)* by (Xu, Y v)∈SC if and only if C├X.u⊂Y.v. Then SC is a regular set, and an automaton Q to recognize SC can be constructed in O(|C|3) time. The proof for this theorem can be found in Noonan.

The example embodiments add at least two novelties: first, the example embodiments support contravariant stack symbols by encoding variance data into the control states and rewrite rules. The second novelty involves the rule S-POINTER; this rule is problematic since the natural encoding would result in infinitely many rewrite rules. The example embodiments extend Caucal's (see D. Caucal, “On the regular structure of prefix rewriting”, Theoretical Computer Science, 106(1):61-86, 1992) construction to lazily instantiate all or substantially all necessary applications of S-POINTER during saturation. The details may be found in Noonan at Appendix D.

Since C will usually entail an infinite number of constraints, this theorem is particularly useful: it asserts that the full set of constraints entailed by C has a finite encoding by an automaton Q. Further manipulations on the constraint closure can be carried out on Q, such as efficient minimization. By restricting the transitions to and from # START and # END, the same algorithm is used to eliminate type variables, producing the desired constraint simplifications.

FIG. 1 illustrates a flowchart for type inference from a stripped binary according to some example embodiments. The process for type reconstruction 100 can be implemented on one or more computers in order to determine the type information for variables, constants etc., that are used in an input binary file which may be an executable file of one or more programs. FIG. 3 shows a block diagram of instruction logic components that can be used for implementing process 100, where the respective instruction logic components can be implemented as software, hardware or a combination of both. In some example embodiments, the type reconstruction, such as process 100, is implemented as a module within CodeSurfer® for Binaries. According to many embodiments, by leveraging the multi-platform disassembly capabilities of CodeSurfer®, the type reconstruction can operate on x86, x86-64, and ARM code.

At operation 102, a stripped binary is received. The example embodiments can take as input binaries generated by many compilers. For example, 32-bit x86 binaries for both Linux and Windows, compiled with a variety of gcc and Microsoft Visual C/C++ versions may be used as input. The input binaries may include a mix of executables, static libraries, and DLLs.

At operation 104, the input binary is disassembled to obtain an intermediate representation (IR). A disassembler such as, for example, GrammaTech's static analysis tool CodeSurfer® for Binaries be used to generate an IR of the input stripped binary. The CodeSurfer® operation is described in G. Balakrishnan, R. Gruian, T. Reps, and T. Teitelbaum, “CodeSurfer/x86 —a platform for analyzing x86 executables”, in Compiler Construction, pages 250-254. Springer, 2005. In some embodiments, minimal analysis settings, disabling VSA and nearly all points-to analysis and the like, may be used in the disassembly tool. Unlike conventional type inference algorithms such as TIE (see J. Lee, T. Avgerinos, and D. Brumley, “TIE: Principled reverse engineering of types in binary programs”, in Proceedings of the 18th Annual Network and Distributed System Security Symposium (NDSS '11), 2011) and SecondWrite (see K. ElWazeer, K. Anand, A. Kotha, M. Smithson, and R. Barua, “Scalable variable and data type detection in a binary rewriter”, in Proceedings of the 34th ACM SIGPLAN conference on Programming Language Design and Implementation (PLDI)”, volume 48, pages 51-60. ACM, 2013), which require some modified form of VSA to resolve points-to data, example embodiments can recover high-quality types even from relatively weak points-to information, allowing type inference to proceed even when computing points-to data is too unreliable or expensive. CodeSurfer® performs common program analyses on binaries for multiple CPU architectures, and is used to recover a high-level IR from the raw machine code.

CodeSurfer® achieves platform independence through TSL. Interpreters for a given abstract domain are automatically created from the concrete semantics simply by specifying the abstract domain A and an interpretation of the concrete numeric and mapping types. In example embodiments, the CodeSurfer® output of the IR is specified in TSL, which is then processed for type reconstruction.

The IR may be in the form of disassembled code. An example disassembly IR is shown in the middle column of FIG. 6. The shown disassembly IR corresponds to the source code shown in the left column in the same figure. Although one example of an IR is illustrated, persons skilled in the art would appreciate that other intermediate forms of code can be used as the IR.

At operation 106, type constraints are generated. Certain example embodiments uses the recovered IR to determine the number and location of inputs and outputs to each procedure, as well as the program's call graph and per-procedure control-flow graphs. An abstract interpreter then generates sets of type constraints (at least in some example embodiments, per-procedure type constraint sets) from the concrete TSL instruction semantics.

The top right column of FIG. 6 illustrates a type scheme obtained according to example embodiments, from the disassembly shown in the middle column of the same figure. Among other things, the type scheme shows the tags #FileHandle and #SuccessZ that encode inferred higher level purposes. A sample of type constraints generated for the example program of FIG. 6, by applying abstract interpretation, is shown in FIG. 7. By generating type constraints from a TSL-based abstract interpreter, example embodiments can operate uniformly on binaries for any platform supported by CodeSurfer®, including x86, x86-64, and ARM. Some examples of constraint generation were described above, and additional details are described below in relation to FIG. 2. Further details of the abstract semantics for constraint generation can be found in Noonan at Appendix A.

At operation 108, resolved types are applied back to the IR and become visible to the GUI and later analysis phases. Applying types back to the IR makes them available as an input into further algorithms, such as decompilation or pointer analysis. The capability to apply certain inferred types to the IR enables new iterations of type inferring based on previous iterations, and provides for further consistency checking and iterative or recursive type inferring of certain complex types.

At operation 110 the reconstructed types are displayed on a display device or output in another manner (e.g., print, transmit to another application or store in a memory). Prior to output, the final phase of type resolution converts the inferred sketches to C types for presentation to the user. Since C types and sketches are not directly comparable, this resolution phase necessarily involves the application of heuristic conversion policies to approximate each of the inferred type by a respective C type. Restricting the heuristic policies to a single post-inference phase provides the example embodiments with substantial flexibility to generate high-quality, human-readable C types while maintaining soundness and generality during type reconstruction. The bottom right column of FIG. 6 illustrates an example reconstructed type. The corresponding source code, disassembly and generated type scheme are illustrated in the same figure left column, middle column, and top right column, respectively.

FIG. 2 illustrates an example process of generating type constraints from the IR, according to some example embodiments. In some example embodiments, process 200 may be performed during operation 106 shown in FIG. 1.

At operation 202, the example embodiments operate to determine inputs/outputs of each procedure, determine program call graph, and determine per-procedure control flow. This may be performed using a tool, such as CodeSurfer®, that can analyze the IR.

At operation 204, type constraints are generated. Example embodiments, using an abstract interpreter, generate one or more sets of type constraints from the TSL semantics of the IR and other determined information regarding the program such as inputs/outputs of each procedure, program call graph, and per-procedure control flow. The type constraint sets are generated in a bottom-up fashion over the strongly-connected components of the call graph. The bottom-up approach enables simplification of constraint sets as we go; when procedure X calls procedure Y, the simplified constraint set for Y is inserted into the constraint set for X. Whereas, one would expect this would lead to an exponential increase in the constraint set size, but simplification prevents this from happening. Pre-computed type schemes for externally linked functions may be inserted at this stage.

In some embodiments, type constraint generation is performed by a parameterized abstract interpretation TYPE_(A), the parameter A itself being an abstract interpreter that is used to transmit additional analysis information such as, for example, reaching definitions, propagated constants, and value-sets (when available). As stated earlier in this document, if V denotes the set of type variables and C the set of type constraints, then the primitive TSL value-types and map-types for TYPE_(A) are represented by BASETYPE_(TYPEA)=BASETYPE_(A)×2^(V)×2^(C) and MAP[α, β]_(TYPEA)=MAP[α, β]_(A)×2^(C).

Since type constraint generation is a syntactic, flow-insensitive process, flow sensitivity can be regained by pairing with an abstract semantics that carries a summary of flow-sensitive information. Parameterizing the type abstract interpretation by A enables factoring out the particular way in which program variables should be abstracted to types (e.g. static single assignment (SSA) form, reaching definitions, and the like).

With respect to register loads and stores the basic reinterpretations proceed by pairing with the abstract interpreter A. FIG. 11A illustrates an example IR form for a register function. A(reg, s) produces a type variable from the register reg and the A-abstracted register map s″. Register loads are handled similarly as shown in FIG. 11B.

Suppose that A represents the concrete semantics for x86 and A(reg, ⋅) yields a type variable (reg, { }) and no additional constraints. Then the x86 expression mov ebx, eax is represented by the TSL expression regUpdate(S, EBX ( ), regAccess(EAX( ), S)), where S is the initial state (S_(conc), C). After abstract interpretation, C will become C∪{eax⊂ebx}.

In another example, suppose that A represents an abstract semantics that is aware of register reaching definitions, and define A(reg, s) by FIG. 11C where reaching-defs yields the set of definitions of reg that are visible from state s. Then TYPE_(A) at program point q will update the constraint set C to C∪{eaxp⊂ebxq} if p is the lone reaching definition of EAX. If there are multiple reaching definitions P, then the constraint set will become C∪{eaxp⊂t\p∈P}∪{t⊂ebxq}.

FIGS. 11D and 11E illustrate reinterpretations of addition and subtraction operations by the abstract interpreted A. FIG. 11D show an example when x or y have statically determined constant values (e.g., when INT32(n) has a concrete numeric value). FIG. 11E shows an example of addition when neither operand is a statically determined constant. In this case, a fresh type variable is generated representing the result, and a 3-place constraint is generated for the type variable.

FIG. 11F shows an example reinterpretation of memory operations by the interpreter A. Memory accesses are treated similarly to register accesses, except for the use of dereference accesses and the handling of points-to sets. For any abstract A-value a and A-state s, let A(a,s) denote a set of type variables representing the address A in the context s. Furthermore, define PtsToA(a, s) to be a set of type variables representing the values pointed to by a in the context s. The semantics of the N-bit load and store functions memAccess_(N) and memUpdate_(N) are shown in FIG. 11F. Acceptable results have been obtained by using a bare minimum points-to analysis that only tracks constant pointers to the local activation record or the data section. The use of the .load/.store accessors allows tracking of multi-level pointer information without the need for explicit points-to data. The minimal approach tracks just enough points-to information to resolve references to local and global variables.

With respect to procedure invocations, earlier occurring analysis phases are responsible for delineating procedures and gathering data about each procedure's formal-in and formal-out variables, including information about how parameters are stored on the stack or in registers. This data is transformed into a collection of locators associated to each function. Each locator is bound to a type variable representing the formal; the locator is responsible for finding an appropriate set of type variables representing the actual at a call-site, or the corresponding local within the procedure itself.

FIG. 11G illustrates a simple program in machine code that invokes a 32-bit identity function. The procedure id will have two locators: a locator L_(i) for the single parameter, bound to a type variable id_(i); and a locator L_(o) for the single return value, bound to a type variable id_(o).

At the procedure call-site, the locator L_(i) will return the type variable ext4_(p) representing the stack location ext4 tagged by its reaching definition. Likewise, L_(o) will return the type variable eax_(q) to indicate that the actual-out is held in the version of eax that is defined at point q. The locator results are combined with the locator's type variables, resulting in the constraint set {id_(i) ⊂arg0_(id), eax_(r) ⊂id₀}. The interpretations of various operations are described in more detail in Noonan, in Appendix A. FIGS. 11A-11G show pseudocode for one partial implementation of an interpreter A. FIG. 11F shows how points-to data can be incorporated; FIGS. 11D, 11E show how additive constraints can be incorporated; FIGS. 11A, 11B, 11C show how incorporating reaching-definition data can be used when generating type constraints for registers.

By changing the parametric interpreter A, the generated type constraints may be made more precise. The interpreter A might be slow but very precise, or fast but relatively imprecise. Different implementations may weigh these factors differently, leading to different choices about A.

At operation 208, the generated initial constraints are simplified. Each constraint set may be simplified by eliminating type variables that do not belong to a predetermined interface (e.g., the source code control system (SCCS) interface). Another simplification is to introduce a new intermediate type variable in order to replace N*M constraints with N+M constraints. For example, if all of X₁, X₂, X₃, X₄ are less than all of Y₁, Y₂, Y₃, we would need to introduce 4*3=12 constraints (X₁<Y₁, X₂<Y₁, . . . X₄<Y₃). By adding one new variable V, we can use only 4+3=7 constraints (X₁<V, X₂<V, X₃<V, X4<V, and V<Y₁, V<Y₂, V<Y₃). An example simplification algorithm is shown in FIG. 10.

The simplification may utilize a transducer Q constructed from the initial type constraints. According to come embodiments, from the initial type constraints, a pushdown system P_(c) is constructed. The pushdown system P_(c) is constructed so that its derivations model proofs in C. Noonan, which is incorporated by reference, describes the construction of the pushdown system P_(c) in detail in Appendix D. As described in Noonan, during the construction of P_(c), some classes of rules (where the rules are derived from constraints), which have relatively large numbers of rules compared to other classes, may be considered lazily while other classes with lesser number of rules are considered in a more frequent manner.

The pushdown system P_(c) is used to construct a finite state automaton A_(c). The finite state automaton A_(c) is constructed to accept strings that encode some of the behavior of P_(c). Noonan describes the construction of A_(c) in Appendix D.2.

The finite state automaton A_(c) and a saturation algorithm is then used to form a finite state transducer A_(c-sat). A_(c-sat) is constructed to have the simple structure of building up a pop sequence representing an initial state of the pushdown automaton, then building up a push sequence representing a final state. In order to achieve this result, A_(c) is saturated by a technique such as that shown in FIG. 12. The intermediate terms of the form “push u, then pop it again” are unwieldy, and although accepted by A_(c), they are not accepted by A_(c-sat). To remove the necessity for those sequences, A_(c) is saturated by adding additional labeled transitions providing shortcuts to the push/pop subsequences. The saturation algorithm is configured to lazily instantiate transitions which correspond to uses of the S-POINTER-derived rules in point-to constraints. This enables the saturation to operate even though the corresponding pushdown system may have infinitely many rules. Noonan, at appendix D.3, provides further details of constructing A_(c-sat).

The transducer Q is then formed from the finite state transducer A_(c-sat). FIG. 14 Algorithm D.1 illustrates pseudocode for constructing Q. The automaton A_(c-sat) now accepts push/pop sequences representing the changes in the stack during any valid (e.g., permitted) derivation in the pushdown system Δ. After saturation, it can be guaranteed that every derivation is represented by a path which first pops a sequence of tokens, then pushes another sequence of tokens. A productive transition sequence must consist of a sequence of pop edges followed by a sequence of push edges. Unfortunately A_(c-sat) still accepts unproductive transition sequences which push and then immediately pop token sequences. To complete the construction, an automaton Q may be formed by intersecting A_(c-sat) with an automaton for the language of words consisting of only pops, followed by only pushes. This ensures that Q only accepts the productive transition sequences in A_(c-sat). Noonan, at appendix D.4, provides further details of constructing Q.

The transducer Q may be used in embodiments in two places during type analysis: first, by computing Q relative to the type variable of a function, a transducer is obtained that represents all elementary derivations of relationships between the function's inputs and outputs. FIG. 15 illustrates an example algorithm used to convert the transducer Q back to a pushdown system P_(c), such that Q describes all valid derivations in P_(c). Then the rules in P_(c) can be interpreted as subtype constraints, resulting in a simplification of the constraint set relative to the formal type variables.

The type simplification stage may result in types that are very general. Often, this means that types are found to be more general than is strictly helpful to an observer, which may be a human observer or another program/machine. A policy referred to herein as REFINEPARAMETERS can used to specialize type schemes to the most specific scheme that is compatible with all uses. For example, a C++ object may include a getter function with a highly polymorphic type scheme, since it could operate equally well on any structure with a field of the right type at the right offset. But it may be expected that in every calling context, the getter will be called on a specific object type (or perhaps its derived types). By specializing the function signature, contextual clues are made use of in exchange for generality before presenting a final C type to the user. The example function REFINEPARAMETERS shown in FIG. 16 is used to specialize each function's type sufficiently to match how the function is actually used in a program, at the cost of reduced generality.

At operation 208 sketches are assigned to type variables, and type schemes are specialized based on calling context. Once type schemes are available, the call graph is traversed bottom-up, assigning sketches to type variables. During this stage, type schemes are specialized based on the calling contexts of each function.

By computing Q relative to the set of type constants a transducer can be obtained that can be efficiently queried to determine which derived type variables are bound above or below by which type constants. This is used by the SOLVE procedure shown in pseudocode in FIG. 13 to populate lattice elements decorating the inferred sketches.

The inventors found that adding these decorations (e.g., markings from the lattice) to the sketches helped preserve high-level types of interest to the end user during type inference. This allows recovery of high-level C and Windows typedefs such as size_t, FILE, HANDLE, and SOCKET that are useful for program understanding and reverse engineering.

Decorations also enable a simple mechanism by which the user can extend the example embodiments' type system, adding semantic purposes (e.g., referred to sometimes as “purpose constraints”) to the types for known functions. For example, Λ can be extended to add seeds for a tag #signal-number attached to the less-informative int parameter to signal( ). This approach also allows us to distinguish between opaque typedefs and the underlying type, as in HANDLE and void*. Since the semantics of a HANDLE are quite distinct from those of a void*, it is important to have a mechanism that can preserve the typedef name.

Sketches is the choice of entity for modeling solutions to the constraint sets in example embodiments. An advantage of sketches may be that they are almost a free tree model of the constraint language. Any constraint set C is satisfiable over the lattice of sketches, as long as C cannot prove an impossible subtype relation in Λ. The same pushdown system construction that appears during constraint simplification to answer queries about which type constants are upper and lower bounds on a given derived type variable may be used for labeling lattices. The computation of upper and lower lattice bounds on a derived type variable can be found in Noonan at Appendix D.4.

FIG. 17 illustrates pseudocode for an example sketch generation process for use in at least some example embodiments. FIGS. 18A and 18B show example sketches. FIG. 18A is a sketch representing a linked list of strings struct LL{str s; struct LL* a;} *. FIG. 18A shows a sketch as a deterministic finite state automata with each state labeled by an element from Λ. This automatic may be formed by collapsing equal subtrees that makeup the sketch. FIG. 18B shows another example sketch. FIG. 15 produces the input to FIG. 14 (the set of pushdown system rules delta). FIG. 19 is the sketch (in the sense of the paper) that solves the constraint set in the upper-right corner of FIG. 6. Converting FIG. 19 to C types results in the types shown in the bottom-right of FIG. 6. Details of the sketch in FIG. 18A can be found in Noonan at Appendix E. FIG. 19 illustrates a sketch instantiating the type scheme in FIG. 6.

At operation 210, convert inferred sketches to C types applying heuristic conversion policies. The final phase of type resolution converts the inferred sketches to C types for presentation to the user. Sketches are traversed top-down, applying heuristics. For example, if a sketch node has outgoing “load” or “store” edges, then we create a C pointer type. The pointed-to type will then be derived by applying the heuristics to the target of the “load” or “store” edge. Similarly, if a type is accessed at several different offsets, we create a C struct type with fields at the corresponding offsets. Cycles in the sketch correspond to recursive types, so we will create C structs with recursive fields when a cycle is traversed. Since C types and sketches are not directly comparable, this resolution phase necessarily involves the application of heuristic conversion policies. Other heuristics include forming union types when the sketch conforms to the shape of two or more different C types. Restricting the heuristic policies to a single post-inference phase provides the example embodiments with substantial flexibility to generate high-quality, human-readable C types while maintaining soundness and generality during type reconstruction.

FIG. 3 shows a block diagram illustrating the instruction logic components providing for the processes 100 and 200. A processing component 300 includes a disassembling instruction logic component 302, type reconstruction instruction logic 304, rule instruction logic 306, and type heuristics instruction logic 308. Components 302-308 may be implemented in software, or using a combination of software hardware. Instruction logic component 302 may comprise a disassembler such as, for example, CodeSurfer®. Type reconstruction instruction logic 304 may include the logic for processes 100 and 200. Rule instruction logic 306 includes the logic for implementing the rules for constraint creation and for inference. The type heuristic logic 308 includes instruction logic for implementing the heuristic rules for converting the inferred types to C types (other program language types). Components 302-308 may be stored on a persistent memory of a computer when not in use, and may, at least partially, be loaded into the volatile memory of the computer when active.

The intermediate representation 310 may be generated by the disassembling component 302, and stored in the volatile memory of the computer. Reconstructed type information 312 may be stored on persistent or volatile memory, and may be either displayed to a display of the computer or output by a network or other interface of the computer.

It will be appreciated that certain example embodiments may run in connection with a standalone or networked computer and/or computer system comprising a plurality of computer nodes. In an example runtime environment, for example, an instance of a process for hardening application programs according to an embodiment may run in memory. Components may include, for example, memory, at least one processor, a data store, an OS kernel, etc. It will be appreciated that such an environment may be used in connection with, or be simply backed by an embodiment as shown in FIGS. 1-3. It also will be appreciated that certain example embodiments may work in any design time and/or runtime environment including, for example, Windows, Linux, Unix, MacOS, and/or other operating systems present on the example electronic devices mentioned above. In a similar vein, the techniques described herein may be used in any suitable combination, sub-combination, or combination of sub-combinations, e.g., as appropriate to the programming language, runtime environment, etc. With respect to the former, for example, certain example embodiments may be made to work with programming languages including, for example, C, C++, Assembler, Java, etc. The programming language may be a compiled or interpreted language, and may run on a physical or virtual machine.

It will be appreciated that as used herein, the terms system, subsystem, service, programmed logic circuitry, and the like may be implemented as any suitable combination of software, hardware, firmware, and/or the like. It also will be appreciated that the storage locations herein may be any suitable combination of disk drive devices, memory locations, solid state drives, CD-ROMs, DVDs, tape backups, storage area network (SAN) systems, and/or any other appropriate tangible computer readable storage medium. It also will be appreciated that the techniques described herein may be accomplished by having a processor (e.g., central processing unit (CPU) or specialized processor) execute instructions that may be tangibly stored on a computer readable storage medium.

While the invention has been described in connection with what is presently considered to be the most practical and preferred embodiment, it is to be understood that the invention is not to be limited to the disclosed embodiment, but on the contrary, is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims. 

What is claimed is:
 1. A method performed by at least one processor to infer types from a program, the method comprising: receiving a machine code of the program; generating an intermediate representation of the machine code; generating a plurality of type constraints from the intermediate representation; generating, based at least upon the plurality of type constraints, one or more inferred types; converting the generated inferred types to C types; updating the intermediate representation by applying the inferred types to the intermediate representation; and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation, wherein the generating one or more inferred types comprises assigning a sketch to each of said inferred types, wherein the converting to C types includes converting each sketch to one or more of said C types, and wherein each sketch includes a record of capabilities and applicable type variables and/or type constants of the inferred type to which it is assigned.
 2. The method of claim 1, wherein the sketch is represented by a tree data structure, and wherein edges of the tree represent labels corresponding to said capabilities and nodes of the tree represent said type variables or said type constants, assigned sketches being arrangable in a lattice formed by markings relating respective sketches to one or more other sketches.
 3. A non-transitory computer-readable storage medium having instruction stored therein to, when executed by at least one processor of a computer, cause the computer to perform operations comprising: receiving a machine code of a program; generating an intermediate representation of the machine code; generating a plurality of type constraints from the intermediate representation; generating, based at least upon the plurality of type constraints, one or more inferred types; converting the generated inferred types to C types; updating the intermediate representation by applying the inferred types to the intermediate representation; and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation, wherein the generating one or more inferred types comprises assigning a sketch to each of said inferred types, wherein the converting to C types includes converting each sketch to one or more of said C types, and wherein each sketch includes a record of capabilities and applicable type variables and/or type constants of the inferred type to which it is assigned.
 4. A computing system comprising at least one memory, a display and at least one processor, configured to execute functionality comprising: receiving a machine code of a program; generating an intermediate representation of the machine code; generating a plurality of type constraints from the intermediate representation; generating, based at least upon the plurality of type constraints, one or more inferred types; converting the generated inferred types to C types; updating the intermediate representation by applying the inferred types to the intermediate representation; and outputting said inferred types, said converted C types, and/or at least a portion of the updated intermediate representation, wherein the generating one or more inferred types comprises assigning a sketch to each of said inferred types, wherein the converting to C types includes converting each sketch to one or more of said C types, and wherein each sketch includes a record of capabilities and applicable type variables and/or type constants of the inferred type to which it is assigned.
 5. The computing system according to claim 4, wherein said converting the generated inferred types to C types is performed after the inferred types are generated from the intermediate representation.
 6. The computing system according to claim 4, wherein each sketch is represented by a tree data structure, and wherein edges of the tree represent labels corresponding to said capabilities and nodes of the tree represent said type variables or said type constants.
 7. The computing system according to claim 4, wherein assigned sketches are arranged in a lattice formed by markings relating respective sketches to one or more other sketches.
 8. The computing system according to claim 7, wherein a type constraint is represented in the lattice by a path from the root with a label sequence.
 9. The computing system according to claim 7, wherein at least one of the markings is configured to encode higher level information including typedef name information.
 10. The computer system according to claim 4, wherein the generating a plurality of type constraints from the intermediate representation comprises at least one of (A) determining inputs/outputs of each procedure, (B) determining a program call graph, and (C) determining per-procedure control flow.
 11. The computing system according to claim 10, further configured to execute functionality comprising using an abstract interpreter, generating sets of type constraints from concrete TSL semantics, inserting type schemes for externally linked functions, and simplifying each constraint set.
 12. The computing system according to claim 11, further configured to execute functionality comprising assigning sketches to type variables, and specializing type schemes based on calling contexts.
 13. The computing system according to claim 12, further configured to execute functionality comprising converting inferred sketches to C types applying heuristic conversion policies.
 14. The computing system according to claim 4, wherein generating the inferred types is based upon subtyping.
 15. The computing system according to claim 4, wherein the subtyping is implemented using type scheme specialization of subtype based constraint sets.
 16. The computing system according to claim 4, wherein generating the inferred types includes interpreting recursive data structures.
 17. The computing system according to claim 4, wherein the at least one processor is further configured to provide for an end user to define or adjust an initial type hierarchy at run time.
 18. The computing system according to claim 4, wherein the generating a plurality of type constraints includes splitting out read and write capabilities of a pointer to have separate constraints in the plurality of type constraints.
 19. The computing system according to claim 4, wherein the plurality of type constraints are generated in a bottom-up fashion over the strongly-connected components of the call graph, and wherein sketches are assigned to type variables while the call graph is being traversed bottom-up.
 20. The computing system according to claim 4, wherein the generating of the plurality of type constraints includes creating a simplified plurality of type constraints by operations including lazily evaluates pointer derived constraints, while non-lazily evaluating other constraints. 